FastAPI Dependency Injection: Προηγμένη Αρχιτεκτονική Container DI

Το FastAPI, με τον διαισθητικό σχεδιασμό και τις ισχυρές δυνατότητές του, έχει γίνει αγαπημένο για τη δημιουργία σύγχρονων web APIs στην Python. Ένα από τα βασικά πλεονεκτήματά του έγκειται στην απρόσκοπτη ενσωμάτωσή του με το dependency injection (DI), επιτρέποντας στους προγραμματιστές να δημιουργούν χαλαρά συνδεδεμένες, ελεγχόμενες και συντηρήσιμες εφαρμογές. Ενώ το ενσωματωμένο σύστημα DI του FastAPI είναι εξαιρετικό για απλές περιπτώσεις χρήσης, πιο σύνθετα έργα συχνά επωφελούνται από μια πιο δομημένη και προηγμένη αρχιτεκτονική DI container. Αυτό το άρθρο διερευνά διάφορες στρατηγικές για τη δημιουργία μιας τέτοιας αρχιτεκτονικής, παρέχοντας πρακτικά παραδείγματα και ιδέες για τον σχεδιασμό ισχυρών και επεκτάσιμων εφαρμογών.

Κατανόηση του Dependency Injection (DI) και του Inversion of Control (IoC)

Πριν ασχοληθούμε με προηγμένες αρχιτεκτονικές DI container, ας ξεκαθαρίσουμε τις θεμελιώδεις έννοιες:

• Dependency Injection (DI): Ένα μοτίβο σχεδίασης όπου οι εξαρτήσεις παρέχονται σε ένα στοιχείο από εξωτερικές πηγές αντί να δημιουργούνται εσωτερικά. Αυτό προάγει τη χαλαρή σύζευξη, καθιστώντας τα στοιχεία ευκολότερα στον έλεγχο και την επαναχρησιμοποίηση.
• Inversion of Control (IoC): Μια ευρύτερη αρχή όπου ο έλεγχος της δημιουργίας και διαχείρισης αντικειμένων αντιστρέφεται – ανατίθεται σε ένα πλαίσιο ή container. Το DI είναι ένας συγκεκριμένος τύπος IoC.

Το FastAPI υποστηρίζει εγγενώς το DI μέσω του συστήματος εξαρτήσεων του. Ορίζετε εξαρτήσεις ως καλούμενα αντικείμενα (συναρτήσεις, κλάσεις, κ.λπ.) και το FastAPI επιλύει και τα εισάγει αυτόματα στις συναρτήσεις τελικού σημείου ή σε άλλες εξαρτήσεις.

Παράδειγμα (Βασικό FastAPI DI):

            
from fastapi import FastAPI, Depends

app = FastAPI()

# Dependency
def get_db():
    db = {"items": []}  # Simulate a database connection
    try:
        yield db
    finally:
        # Close the database connection (if needed)
        pass


# Endpoint with dependency injection
@app.get("/items/")
async def read_items(db: dict = Depends(get_db)):
    return db["items"]

            

              
                Copy
              
            
          

Σε αυτό το παράδειγμα, το get_db είναι μια εξάρτηση που παρέχει μια σύνδεση βάσης δεδομένων. Το FastAPI καλεί αυτόματα το get_db και εισάγει το αποτέλεσμα (το λεξικό db) στη συνάρτηση τελικού σημείου read_items.

Γιατί ένα Προηγμένο DI Container;

Το ενσωματωμένο DI του FastAPI λειτουργεί καλά για απλά έργα, αλλά καθώς οι εφαρμογές αυξάνονται σε πολυπλοκότητα, ένα πιο εξελιγμένο DI container προσφέρει πολλά πλεονεκτήματα:

• Κεντρική Διαχείριση Εξαρτήσεων: Ένα αποκλειστικό container παρέχει μια ενιαία πηγή αλήθειας για όλες τις εξαρτήσεις, διευκολύνοντας τη διαχείριση και την κατανόηση των εξαρτήσεων της εφαρμογής.
• Διαχείριση Διαμόρφωσης και Κύκλου Ζωής: Το container μπορεί να χειριστεί τη διαμόρφωση και τον κύκλο ζωής των εξαρτήσεων, όπως η δημιουργία singletons, η διαχείριση συνδέσεων και η απόρριψη πόρων.
• Δυνατότητα Ελέγχου: Ένα προηγμένο container απλοποιεί τον έλεγχο, επιτρέποντάς σας να παρακάμψετε εύκολα τις εξαρτήσεις με ψεύτικα αντικείμενα ή διπλάσια δοκιμής.
• Αποσύνδεση: Προωθεί μεγαλύτερη αποσύνδεση μεταξύ των στοιχείων, μειώνοντας τις εξαρτήσεις και βελτιώνοντας τη συντηρησιμότητα του κώδικα.
• Επεκτασιμότητα: Ένα επεκτάσιμο container σάς επιτρέπει να προσθέσετε προσαρμοσμένες δυνατότητες και ενσωματώσεις όπως απαιτείται.

Στρατηγικές για τη Δημιουργία ενός Προηγμένου DI Container

Υπάρχουν διάφορες προσεγγίσεις για τη δημιουργία ενός προηγμένου DI container στο FastAPI. Ακολουθούν μερικές κοινές στρατηγικές:

1. Χρήση μιας Αποκλειστικής Βιβλιοθήκης DI (π.χ., `injector`, `dependency_injector`)

Διατίθενται πολλές ισχυρές βιβλιοθήκες DI για την Python, όπως οι injector και dependency_injector. Αυτές οι βιβλιοθήκες παρέχουν ένα ολοκληρωμένο σύνολο δυνατοτήτων για τη διαχείριση εξαρτήσεων, συμπεριλαμβανομένων:

• Δέσμευση: Ορισμός του τρόπου επίλυσης και εισαγωγής των εξαρτήσεων.
• Πεδίο Εφαρμογής: Έλεγχος του κύκλου ζωής των εξαρτήσεων (π.χ., singleton, transient).
• Διαμόρφωση: Διαχείριση ρυθμίσεων διαμόρφωσης για εξαρτήσεις.
• AOP (Aspect-Oriented Programming): Παρακώλυση κλήσεων μεθόδων για εγκάρσιες ανησυχίες.

Παράδειγμα με `dependency_injector`

Το dependency_injector είναι μια δημοφιλής επιλογή για τη δημιουργία DI container. Ας απεικονίσουμε τη χρήση του με ένα παράδειγμα:

            
from dependency_injector import containers, providers
from fastapi import FastAPI, Depends

# Define dependencies
class Database:
    def __init__(self, connection_string: str):
        self.connection_string = connection_string
        # Initialize database connection
        print(f"Connecting to database: {self.connection_string}")

    def get_items(self):
        # Simulate fetching items from the database
        return [{"id": 1, "name": "Item 1"}, {"id": 2, "name": "Item 2"}]


class UserRepository:
    def __init__(self, database: Database):
        self.database = database

    def get_all_users(self):
        # Simulating database request to get all users
        return [{"id": "user1", "name": "Alice"},{"id": "user2", "name": "Bob"}]

class Settings:
    def __init__(self, database_url):
        self.database_url = database_url

# Define container
class Container(containers.DeclarativeContainer):
    config = providers.Configuration()
    settings = providers.Singleton(Settings, database_url = config.database_url)
    database = providers.Singleton(Database, connection_string=config.database_url)
    user_repository = providers.Factory(UserRepository, database=database)

# Create FastAPI app
app = FastAPI()

# Configure container (from an environment variable)
container = Container()
container.config.database_url.from_env("DATABASE_URL", default="sqlite:///:memory:")
container.wire([__name__]) # enables injection of dependencies into FastAPI endpoints

# Dependency for FastAPI
def get_user_repository(user_repository: UserRepository = Depends(container.user_repository.provided)) -> UserRepository:
    return user_repository


# Endpoint using injected dependency
@app.get("/users/")
async def read_users(user_repository: UserRepository = Depends(get_user_repository)):
    return user_repository.get_all_users()

@app.on_event("startup")
async def startup_event():
    # Container initialization
    container.init_resources()

            

              
                Copy
              
            
          

Επεξήγηση:

• Ορίζουμε τις εξαρτήσεις μας (Database, UserRepository, Settings) ως κανονικές κλάσεις Python.
• Δημιουργούμε μια κλάση Container που κληρονομεί από το containers.DeclarativeContainer. Αυτή η κλάση ορίζει τις εξαρτήσεις και τους παρόχους τους (π.χ., providers.Singleton για singletons, providers.Factory για δημιουργία νέων στιγμιότυπων κάθε φορά).
• Η γραμμή container.wire([__name__]) επιτρέπει την εισαγωγή εξαρτήσεων στα τελικά σημεία του FastAPI.
• Η συνάρτηση get_user_repository είναι μια εξάρτηση του FastAPI που χρησιμοποιεί το container.user_repository.provided για να ανακτήσει το στιγμιότυπο UserRepository από το container.
• Η συνάρτηση τελικού σημείου read_users εισάγει την εξάρτηση UserRepository.
• Η `config` σας επιτρέπει να εξωτερικεύσετε τις διαμορφώσεις εξαρτήσεων. Στη συνέχεια, μπορεί να προέλθει από μεταβλητές περιβάλλοντος, αρχεία διαμόρφωσης κ.λπ.
• Το `startup_event` χρησιμοποιείται για την προετοιμασία των πόρων που διαχειρίζονται στο container

2. Υλοποίηση ενός Προσαρμοσμένου DI Container

Για περισσότερο έλεγχο στη διαδικασία DI, μπορείτε να υλοποιήσετε ένα προσαρμοσμένο DI container. Αυτή η προσέγγιση απαιτεί περισσότερη προσπάθεια, αλλά σας επιτρέπει να προσαρμόσετε το container στις συγκεκριμένες ανάγκες σας.

Βασικό Παράδειγμα Προσαρμοσμένου DI Container:

            
from typing import Callable, Dict, Type, Any
from fastapi import FastAPI, Depends

class Container:
    def __init__(self):
        self.dependencies: Dict[Type[Any], Callable[..., Any]] = {}
        self.instances: Dict[Type[Any], Any] = {}

    def register(self, dependency_type: Type[Any], provider: Callable[..., Any]):
        self.dependencies[dependency_type] = provider

    def resolve(self, dependency_type: Type[Any]) -> Any:
        if dependency_type in self.instances:
            return self.instances[dependency_type]

        if dependency_type not in self.dependencies:
            raise Exception(f"Dependency {dependency_type} not registered.")

        provider = self.dependencies[dependency_type]
        instance = provider()
        return instance

    def singleton(self, dependency_type: Type[Any], provider: Callable[..., Any]):
        self.register(dependency_type, provider)
        self.instances[dependency_type] = provider()


# Example Dependencies
class PaymentGateway:
    def process_payment(self, amount: float) -> bool:
        print(f"Processing payment of ${amount}")
        return True # Simulate successful payment


class NotificationService:
    def send_notification(self, message: str):
        print(f"Sending notification: {message}")


# Example Usage
container = Container()
container.singleton(PaymentGateway, PaymentGateway)
container.singleton(NotificationService, NotificationService)

app = FastAPI()

# FastAPI Dependency
def get_payment_gateway(payment_gateway: PaymentGateway = Depends(lambda: container.resolve(PaymentGateway))):
    return payment_gateway


def get_notification_service(notification_service: NotificationService = Depends(lambda: container.resolve(NotificationService))):
    return notification_service


@app.post("/purchase/")
async def purchase_item(payment_gateway: PaymentGateway = Depends(get_payment_gateway), notification_service: NotificationService = Depends(get_notification_service)):
    if payment_gateway.process_payment(100.0):
        notification_service.send_notification("Purchase successful!")
        return {"message": "Purchase successful"}
    else:
        return {"message": "Purchase failed"}

            

              
                Copy
              
            
          

Επεξήγηση:

• Η κλάση Container διαχειρίζεται ένα λεξικό εξαρτήσεων και των παρόχων τους.
• Η μέθοδος register καταχωρεί μια εξάρτηση με τον πάροχό της.
• Η μέθοδος resolve επιλύει μια εξάρτηση καλώντας τον πάροχό της.
• Η μέθοδος singleton καταχωρεί μια εξάρτηση και δημιουργεί ένα μόνο στιγμιότυπο της.
• Οι εξαρτήσεις FastAPI δημιουργούνται χρησιμοποιώντας μια συνάρτηση lambda για την επίλυση εξαρτήσεων από το container.

3. Χρήση του `Depends` του FastAPI με μια Συνάρτηση Factory

Αντί για ένα πλήρες DI container, μπορείτε να χρησιμοποιήσετε το Depends του FastAPI μαζί με συναρτήσεις factory για να επιτύχετε κάποιο επίπεδο διαχείρισης εξαρτήσεων. Αυτή η προσέγγιση είναι απλούστερη από την υλοποίηση ενός προσαρμοσμένου container, αλλά εξακολουθεί να παρέχει ορισμένα πλεονεκτήματα σε σχέση με την άμεση δημιουργία στιγμιότυπων εξαρτήσεων εντός συναρτήσεων τελικού σημείου.

            
from fastapi import FastAPI, Depends
from typing import Callable

# Define Dependencies
class EmailService:
    def __init__(self, smtp_server: str):
        self.smtp_server = smtp_server

    def send_email(self, recipient: str, subject: str, body: str):
        print(f"Sending email to {recipient} via {self.smtp_server}: {subject} - {body}")


# Factory function for EmailService
def create_email_service(smtp_server: str) -> EmailService:
    return EmailService(smtp_server=smtp_server)


# FastAPI
app = FastAPI()

# FastAPI Dependency, leveraging factory function and Depends
def get_email_service(email_service: EmailService = Depends(lambda: create_email_service(smtp_server="smtp.example.com"))):
    return email_service


@app.post("/send-email/")
async def send_email(recipient: str, subject: str, body: str, email_service: EmailService = Depends(get_email_service)):
    email_service.send_email(recipient=recipient, subject=subject, body=body)
    return {"message": "Email sent!"}

            

              
                Copy
              
            
          

Επεξήγηση:

• Ορίζουμε μια συνάρτηση factory (create_email_service) που δημιουργεί στιγμιότυπα της εξάρτησης EmailService.
• Η εξάρτηση get_email_service χρησιμοποιεί το Depends και μια lambda για να καλέσει τη συνάρτηση factory και να παρέχει ένα στιγμιότυπο του EmailService.
• Η συνάρτηση τελικού σημείου send_email εισάγει την εξάρτηση EmailService.

Προηγμένες Σκέψεις

1. Πεδίο Εφαρμογής και Κύκλοι Ζωής

Τα DI container συχνά παρέχουν δυνατότητες για τη διαχείριση του κύκλου ζωής των εξαρτήσεων. Τα κοινά πεδία εφαρμογής περιλαμβάνουν:

• Singleton: Δημιουργείται ένα μόνο στιγμιότυπο της εξάρτησης και επαναχρησιμοποιείται καθ' όλη τη διάρκεια ζωής της εφαρμογής. Αυτό είναι κατάλληλο για εξαρτήσεις που είναι stateless ή έχουν καθολικό πεδίο εφαρμογής.
• Transient: Δημιουργείται ένα νέο στιγμιότυπο της εξάρτησης κάθε φορά που ζητείται. Αυτό είναι κατάλληλο για εξαρτήσεις που είναι stateful ή πρέπει να απομονωθούν μεταξύ τους.
• Request: Δημιουργείται ένα μόνο στιγμιότυπο της εξάρτησης για κάθε εισερχόμενο αίτημα. Αυτό είναι κατάλληλο για εξαρτήσεις που πρέπει να διατηρήσουν την κατάσταση στο πλαίσιο ενός μόνο αιτήματος.

Η βιβλιοθήκη dependency_injector παρέχει ενσωματωμένη υποστήριξη για πεδία εφαρμογής. Για προσαρμοσμένα container, θα χρειαστεί να υλοποιήσετε μόνοι σας τη λογική διαχείρισης πεδίου εφαρμογής.

2. Διαμόρφωση

Οι εξαρτήσεις συχνά απαιτούν ρυθμίσεις διαμόρφωσης, όπως συμβολοσειρές σύνδεσης βάσης δεδομένων, κλειδιά API και σημαίες δυνατοτήτων. Τα DI container μπορούν να βοηθήσουν στη διαχείριση αυτών των ρυθμίσεων παρέχοντας έναν κεντρικό τρόπο πρόσβασης και εισαγωγής τιμών διαμόρφωσης.

Στο παράδειγμα dependency_injector, ο πάροχος config επιτρέπει τη διαμόρφωση από μεταβλητές περιβάλλοντος. Για προσαρμοσμένα container, μπορείτε να φορτώσετε τη διαμόρφωση από αρχεία ή μεταβλητές περιβάλλοντος και να τα αποθηκεύσετε στο container.

3. Έλεγχος

Ένα από τα κύρια οφέλη του DI είναι η βελτιωμένη δυνατότητα ελέγχου. Με ένα DI container, μπορείτε εύκολα να αντικαταστήσετε τις πραγματικές εξαρτήσεις με ψεύτικα αντικείμενα ή διπλάσια δοκιμής κατά τη διάρκεια του ελέγχου.

Παράδειγμα (Έλεγχος με `dependency_injector`):

            
import pytest
from unittest.mock import MagicMock
from dependency_injector import containers, providers
from fastapi import FastAPI, Depends
from fastapi.testclient import TestClient

# Define dependencies (same as before)
class Database:
    def __init__(self, connection_string: str):
        self.connection_string = connection_string

    def get_items(self):
        return [{"id": 1, "name": "Item 1"}, {"id": 2, "name": "Item 2"}]


class UserRepository:
    def __init__(self, database: Database):
        self.database = database

    def get_all_users(self):
        return [{"id": "user1", "name": "Alice"},{"id": "user2", "name": "Bob"}]

class Settings:
    def __init__(self, database_url):
        self.database_url = database_url

# Define container (same as before)
class Container(containers.DeclarativeContainer):
    config = providers.Configuration()
    settings = providers.Singleton(Settings, database_url = config.database_url)
    database = providers.Singleton(Database, connection_string=config.database_url)
    user_repository = providers.Factory(UserRepository, database=database)

# Create FastAPI app (same as before)
app = FastAPI()

# Configure container (from an environment variable)
container = Container()
container.config.database_url.from_env("DATABASE_URL", default="sqlite:///:memory:")
container.wire([__name__]) # enables injection of dependencies into FastAPI endpoints

# Dependency for FastAPI
def get_user_repository(user_repository: UserRepository = Depends(container.user_repository.provided)) -> UserRepository:
    return user_repository


# Endpoint using injected dependency (same as before)
@app.get("/users/")
async def read_users(user_repository: UserRepository = Depends(get_user_repository)):
    return user_repository.get_all_users()

@app.on_event("startup")
async def startup_event():
    # Container initialization
    container.init_resources()

# Test
@pytest.fixture
def test_client():
    # Override the database dependency with a mock
    database_mock = MagicMock(spec=Database)
    database_mock.get_items.return_value = [{"id": 3, "name": "Test Item"}]

    user_repository_mock = MagicMock(spec = UserRepository)
    user_repository_mock.get_all_users.return_value = [{"id": "test_user", "name": "Test User"}]

    # Override container with mock dependencies
    container.user_repository.override(providers.Factory(lambda: user_repository_mock))

    with TestClient(app) as client:
        yield client
    container.user_repository.reset()


def test_read_users(test_client: TestClient):
    response = test_client.get("/users/")
    assert response.status_code == 200
    assert response.json() ==  [{"id": "test_user", "name": "Test User"}]

            

              
                Copy
              
            
          

Επεξήγηση:

• Δημιουργούμε ένα ψεύτικο αντικείμενο για την εξάρτηση Database χρησιμοποιώντας το MagicMock.
• Παρακάμπτουμε τον πάροχο database στο container με το ψεύτικο αντικείμενο χρησιμοποιώντας το container.database.override().
• Η συνάρτηση ελέγχου test_read_items χρησιμοποιεί τώρα την ψεύτικη εξάρτηση βάσης δεδομένων.
• Μετά την εκτέλεση της δοκιμής, επαναφέρει την υπερκαλυμμένη εξάρτηση του container.

4. Ασύγχρονες Εξαρτήσεις

Το FastAPI είναι χτισμένο πάνω από τον ασύγχρονο προγραμματισμό (async/await). Όταν εργάζεστε με ασύγχρονες εξαρτήσεις (π.χ. ασύγχρονες συνδέσεις βάσης δεδομένων), βεβαιωθείτε ότι το DI container και οι πάροχοι εξαρτήσεων υποστηρίζουν ασύγχρονες λειτουργίες.

Παράδειγμα (Ασύγχρονη Εξάρτηση με `dependency_injector`):

            
import asyncio
from dependency_injector import containers, providers
from fastapi import FastAPI, Depends

# Define asynchronous dependency
class AsyncDatabase:
    def __init__(self, connection_string: str):
        self.connection_string = connection_string

    async def connect(self):
        print(f"Connecting to database: {self.connection_string}")
        await asyncio.sleep(0.1) # Simulate connection time

    async def fetch_data(self):
        await asyncio.sleep(0.1) # Simulate database query
        return [{"id": 1, "name": "Async Item 1"}]

# Define container
class Container(containers.DeclarativeContainer):
    config = providers.Configuration()
    database = providers.Singleton(AsyncDatabase, connection_string=config.database_url)

# Create FastAPI app
app = FastAPI()

# Configure container
container = Container()
container.config.database_url.from_env("DATABASE_URL", default="sqlite:///:memory:")
container.wire([__name__])

# Dependency for FastAPI
async def get_async_database(database: AsyncDatabase = Depends(container.database.provided)) -> AsyncDatabase:
    await database.connect()
    return database


# Endpoint using injected dependency
@app.get("/async-items/")
async def read_async_items(database: AsyncDatabase = Depends(get_async_database)):
    data = await database.fetch_data()
    return data


@app.on_event("startup")
async def startup_event():
    # Container initialization
    container.init_resources()

            

              
                Copy
              
            
          

Επεξήγηση:

• Η κλάση AsyncDatabase ορίζει ασύγχρονες μεθόδους χρησιμοποιώντας async και await.
• Η εξάρτηση get_async_database ορίζεται επίσης ως ασύγχρονη συνάρτηση.
• Η συνάρτηση τελικού σημείου read_async_items επισημαίνεται ως async και αναμένει το αποτέλεσμα του database.fetch_data().

Επιλογή της Σωστής Προσέγγισης

Η καλύτερη προσέγγιση για τη δημιουργία ενός προηγμένου DI container εξαρτάται από την πολυπλοκότητα της εφαρμογής σας και τις συγκεκριμένες απαιτήσεις σας:

• Για μικρά έως μεσαία έργα: Το ενσωματωμένο DI του FastAPI ή μια προσέγγιση συνάρτησης factory με το Depends μπορεί να είναι αρκετή.
• Για μεγαλύτερα, πιο σύνθετα έργα: Μια αποκλειστική βιβλιοθήκη DI όπως το dependency_injector παρέχει ένα ολοκληρωμένο σύνολο δυνατοτήτων για τη διαχείριση εξαρτήσεων.
• Για έργα που απαιτούν λεπτομερή έλεγχο στη διαδικασία DI: Η υλοποίηση ενός προσαρμοσμένου DI container μπορεί να είναι η καλύτερη επιλογή.

Συμπέρασμα

Το dependency injection είναι μια ισχυρή τεχνική για τη δημιουργία επεκτάσιμων, συντηρήσιμων και ελεγχόμενων εφαρμογών. Ενώ το ενσωματωμένο σύστημα DI του FastAPI είναι εξαιρετικό για απλές περιπτώσεις χρήσης, μια προηγμένη αρχιτεκτονική DI container μπορεί να προσφέρει σημαντικά οφέλη για πιο σύνθετα έργα. Επιλέγοντας τη σωστή προσέγγιση και αξιοποιώντας τις δυνατότητες των βιβλιοθηκών DI ή υλοποιώντας ένα προσαρμοσμένο container, μπορείτε να δημιουργήσετε ένα ισχυρό και ευέλικτο σύστημα διαχείρισης εξαρτήσεων που βελτιώνει τη συνολική ποιότητα και συντηρησιμότητα των εφαρμογών σας FastAPI.

Παγκόσμιες Σκέψεις

Κατά τον σχεδιασμό DI container για παγκόσμιες εφαρμογές, είναι σημαντικό να λάβετε υπόψη τα ακόλουθα:

• Τοπικοποίηση: Οι εξαρτήσεις που σχετίζονται με την τοπικοποίηση (π.χ. ρυθμίσεις γλώσσας, μορφές ημερομηνιών) θα πρέπει να διαχειρίζονται από το DI container για να διασφαλιστεί η συνέπεια σε διαφορετικές περιοχές.
• Ζώνες Ώρας: Οι εξαρτήσεις που χειρίζονται μετατροπές ζώνης ώρας θα πρέπει να εισάγονται για να αποφεύγεται η σκληρή κωδικοποίηση πληροφοριών ζώνης ώρας.
• Νόμισμα: Οι εξαρτήσεις για τη μετατροπή και τη μορφοποίηση νομισμάτων θα πρέπει να διαχειρίζονται από το container για την υποστήριξη διαφορετικών νομισμάτων.
• Περιφερειακές Ρυθμίσεις: Άλλες περιφερειακές ρυθμίσεις, όπως μορφές αριθμών και μορφές διευθύνσεων, θα πρέπει επίσης να διαχειρίζονται από το DI container.
• Πολλαπλή Μίσθωση: Για εφαρμογές πολλαπλής μίσθωσης, το DI container θα πρέπει να μπορεί να παρέχει διαφορετικές εξαρτήσεις για διαφορετικούς μισθωτές. Αυτό μπορεί να επιτευχθεί χρησιμοποιώντας πεδία ή προσαρμοσμένη λογική επίλυσης εξαρτήσεων.
• Συμμόρφωση και Ασφάλεια: Βεβαιωθείτε ότι η στρατηγική διαχείρισης εξαρτήσεων συμμορφώνεται με τους σχετικούς κανονισμούς περί απορρήτου δεδομένων (π.χ. GDPR, CCPA) και τις βέλτιστες πρακτικές ασφάλειας σε διάφορες περιοχές. Χειριστείτε με ασφάλεια ευαίσθητα διαπιστευτήρια και διαμορφώσεις εντός του container.

Λαμβάνοντας υπόψη αυτούς τους παγκόσμιους παράγοντες, μπορείτε να δημιουργήσετε DI container που είναι κατάλληλα για τη δημιουργία εφαρμογών που λειτουργούν σε ένα παγκόσμιο περιβάλλον.